import 'package:flutter/material.dart';
import 'package:get/get.dart';
import '../../../common/api/index.dart';
import '../../../common/models/index.dart';
import '../../../common/services/index.dart';
import '../../../common/services/business_orchestration_service.dart';
import '../../../common/routers/index.dart';
import '../../../common/utils/loading_util.dart';

class UserInfoController extends GetxController {
  // ==================== 响应式状态 ====================
  
  /// 目标用户ID（要查看的用户）
  final targetUserId = 0.obs;
  
  /// 是否查看自己的信息
  final isMyself = false.obs;
  
  /// 用户信息
  final Rxn<UserEntity> userInfo = Rxn<UserEntity>();
  
  /// 活动列表（进行中的活动）
  final RxList<ActivityEntity> activities = <ActivityEntity>[].obs;
  
  /// 加载状态
  final isLoading = true.obs;
  
  /// 是否正在发送好友申请
  final isAddingFriend = false.obs;
  
  /// 是否显示加好友按钮（检查完好友关系后显示）
  final showAddFriendButton = false.obs;
  
  // ==================== 依赖注入 ====================
  final UserService _userService = Get.find<UserService>();
  
  // ==================== 计算属性 ====================
  
  /// 是否是好友（从UserService获取）
  bool get isFriend => _userService.isFriend(targetUserId.value);
  
  /// 当前登录用户ID
  int get currentUserId => _userService.currentUserProfile?.userid ?? 0;
  
  /// 粉丝数量（查看自己时显示好友数量，查看他人时显示真实粉丝数）
  int get followerCount {
    if (isMyself.value) {
      // 查看自己：显示好友数量
      return _userService.friendCount;
    } else {
      // 查看他人：显示真实粉丝数量
      return userInfo.value?.userFollowers ?? 0;
    }
  }
  
  // ==================== 生命周期 ====================
  
  @override
  void onInit() {
    super.onInit();
    _handleRouteArguments();
  }

  @override
  void onReady() {
    super.onReady();
    _initData();
  }

  // ==================== 路由参数处理 ====================
  
  /// 处理路由参数
  void _handleRouteArguments() {
    debugPrint('🎯 =============== 用户主页加载 ===============');
    
    final args = Get.arguments as Map<String, dynamic>?;
    debugPrint('📦 接收参数: $args');
    
    // 获取目标用户ID
    final userId = args?['userId'] as int?;
    
    // 如果没有传用户ID，默认查看自己
    if (userId == null) {
      targetUserId.value = currentUserId;
      isMyself.value = true;
    } else {
      targetUserId.value = userId;
      isMyself.value = userId == currentUserId;
    }
    
    debugPrint('👤 当前登录用户ID: $currentUserId');
    debugPrint('🎯 目标用户ID: ${targetUserId.value}');
    debugPrint('🔍 是否查看自己: ${isMyself.value}');
  }
  
  // ==================== 数据加载 ====================
  
  /// 初始化数据
  Future<void> _initData() async {
    await loadUserInfo();
  }
  
  /// 加载用户信息
  Future<void> loadUserInfo() async {
    try {
      debugPrint('📡 =============== 加载用户信息 ===============');
      isLoading.value = true;
      
      if (isMyself.value) {
        // 查看自己的信息 - 调用getUserContent接口
        await _loadMyUserInfo();
      } else {
        // 查看他人的信息 - 调用getUserFilteredContent接口
        await _loadOtherUserInfo();
      }
    } catch (e) {
      debugPrint('❌ 加载用户信息失败: $e');
      LoadingUtil.error('加载失败: ${e.toString()}');
    } finally {
      isLoading.value = false;
    }
  }
  
  /// 加载自己的用户信息和活动
  Future<void> _loadMyUserInfo() async {
    debugPrint('📱 加载自己的用户信息...');
    
    // 调用getUserContent接口（查询最近365天的数据）
    final response = await ActivityApi.getUserContent(
      userId: targetUserId.value,
      days: 365,
    );
    
    debugPrint('✅ getUserContent响应: $response');
    
    if (response['status'] == 'success') {
      // 使用本地存储的用户基本信息
      userInfo.value = _userService.currentUserProfile;
      
      // 显示活动列表（只显示进行中的活动）
      final activitiesList = response['activities'] as List<dynamic>?;
      if (activitiesList != null) {
        activities.value = activitiesList
            .map((item) => ActivityEntity.fromJson(item as Map<String, dynamic>))
            .where((activity) => 
                activity.activityStatus?.contains('进行中') ?? false)
            .toList()
            .cast<ActivityEntity>();
        
        debugPrint('📊 活动数据筛选:');
        debugPrint('  总活动数: ${activitiesList.length}');
        debugPrint('  进行中的活动: ${activities.length}');
      } else {
        debugPrint('⚠️ 没有活动数据');
        activities.value = [];
      }
    } else {
      throw Exception(response['message'] ?? '加载失败');
    }
  }
  
  /// 加载他人的用户信息和活动
  Future<void> _loadOtherUserInfo() async {
    debugPrint('👥 加载他人的用户信息...');
    
    // 调用getUserFilteredContent接口
    final response = await UserApi.getUserFilteredContent(
      userId: targetUserId.value,
      contentType: 'activities',
    );
    
    debugPrint('✅ getUserFilteredContent响应: ${response.isSuccess}');
    
    if (response.isSuccess && response.user != null) {
      // 显示他人的用户信息
      userInfo.value = response.user;
      
      // 显示活动列表（只显示进行中的活动）
      if (response.activities != null) {
        // 🔥 先将 Map 转换为 ActivityEntity，再筛选
        final activitiesList = response.activities as List<dynamic>;
        activities.value = activitiesList
            .map((item) => ActivityEntity.fromJson(item as Map<String, dynamic>))
            .where((activity) =>
                activity.activityStatus?.contains('进行中') ?? false)
            .toList();
        
        debugPrint('📊 活动数据筛选:');
        debugPrint('  总活动数: ${activitiesList.length}');
        debugPrint('  进行中的活动: ${activities.length}');
      } else {
        debugPrint('⚠️ 没有活动数据');
        activities.value = [];
      }
      
      // 用户信息加载完成后，检查好友关系
      await _checkFriendRelationship();
    } else {
      throw Exception(response.message ?? '加载失败');
    }
  }
  
  // ==================== 好友关系处理 ====================
  
  /// 检查好友关系（静默检查，不显示加载状态）
  Future<void> _checkFriendRelationship() async {
    try {
      debugPrint('🔍 =============== 开始检查好友关系（静默模式） ===============');
      
      // 如果是查看自己的主页，隐藏加好友按钮
      if (isMyself.value) {
        debugPrint('✅ 这是自己的主页，不显示加好友按钮');
        showAddFriendButton.value = false;
        return;
      }
      
      debugPrint('👤 当前用户ID: $currentUserId');
      debugPrint('👤 目标用户ID: ${targetUserId.value}');
      
      // 🔥 确保好友列表已加载（如果为空，先加载一次）
      if (_userService.friendList.isEmpty) {
        debugPrint('⚠️ 好友列表为空，先加载好友列表...');
        try {
          await _userService.getFriendList(forceRefresh: false);
          debugPrint('✅ 好友列表加载完成，共 ${_userService.friendCount} 个好友');
        } catch (e) {
          debugPrint('❌ 加载好友列表失败: $e');
        }
      } else {
        debugPrint('✅ 好友列表已存在，共 ${_userService.friendCount} 个好友');
      }
      
      debugPrint('🔄 检查好友关系...');
      
      // 使用UserService的好友列表判断
      final isFriendNow = _userService.isFriend(targetUserId.value);
      
      // 检查完成后，决定是否显示加好友按钮
      showAddFriendButton.value = !isFriendNow;
      
      debugPrint('📊 好友关系状态: ${isFriendNow ? "已是好友" : "不是好友"}');
      debugPrint('📊 显示加好友按钮: ${!isFriendNow}');
      
    } catch (error) {
      debugPrint('❌ 好友关系检查失败: $error');
      // 检查失败时，显示加好友按钮（降级处理）
      showAddFriendButton.value = true;
    }
  }
  
  /// 发送好友申请
  Future<void> onAddFriend() async {
    try {
      debugPrint('🤝 =============== 发送好友申请（使用BusinessOrchestrationService） ===============');
      
      if (isAddingFriend.value) {
        debugPrint('⚠️ 正在发送中，请勿重复点击');
        return;
      }
      
      if (currentUserId == 0) {
        LoadingUtil.info('请先登录');
        return;
      }
      
      if (targetUserId.value == 0) {
        LoadingUtil.info('无法获取用户信息');
        return;
      }
      
      isAddingFriend.value = true;
      
      // 🔥 显示加载提示
      LoadingUtil.show('发送好友申请中...');
      
      debugPrint('👤 接收者ID: ${targetUserId.value}');
      
      // 🔥 使用BusinessOrchestrationService统一入口（API + IM通知）
      final result = await BusinessOrchestrationService.to.sendFriendRequest(
        receiverId: targetUserId.value,
        message: '通过用户主页发送的好友申请',
        checkPermission: true,
      );
      
      // 🔥 关闭加载提示
      LoadingUtil.dismiss();
      
      if (result['status'] == 'success') {
        debugPrint('✅ 好友申请发送成功（已自动发送IM通知）');
        
        // 🔥 重新检查好友关系（如果对方曾向我发送申请，我接受了，我们就是好友了）
        // _checkFriendRelationship 会自动加载好友列表
        await _checkFriendRelationship();
      } else if (result['status'] == 'warning') {
        // 🔥 警告状态：重复发送、已是好友、被拒绝等
        debugPrint('⚠️ ${result['message']}');
        LoadingUtil.toast(result['message'] ?? '操作提示');
      } else {
        debugPrint('❌ 好友申请发送失败: ${result['message']}');
        LoadingUtil.error(result['message'] ?? '发送失败，请重试');
      }
      
    } catch (error) {
      // 🔥 关闭加载提示
      LoadingUtil.dismiss();
      
      debugPrint('❌ 好友申请发送失败: $error');
      
      final errorMsg = error.toString();
      
      if (errorMsg.contains('已经是好友') || errorMsg.contains('你们已经是好友了')) {
        showAddFriendButton.value = false;
        LoadingUtil.toast('你们已经是好友了');
      } else if (errorMsg.contains('已经发送') || errorMsg.contains('请等待')) {
        LoadingUtil.toast(errorMsg);
      } else {
        LoadingUtil.error('发送失败，请重试');
      }
    } finally {
      isAddingFriend.value = false;
    }
  }
  
  // ==================== 活动相关 ====================
  
  /// 申请加入活动
  Future<void> onJoinActivity(int index) async {
    try {
      if (index >= activities.length) return;
      
      final activity = activities[index];
      
      debugPrint('🎯 =============== 用户点击加入活动 ===============');
      debugPrint('📝 活动索引: $index');
      debugPrint('📊 活动数据: ${activity.activityTitle}');
      
      // 显示确认对话框
      final confirmed = await Get.dialog<bool>(
        AlertDialog(
          title: const Text('申请加入活动'),
          content: Text('确定要申请加入活动"${activity.activityTitle}"吗？'),
          actions: [
            TextButton(
              onPressed: () => Get.back(result: false),
              child: const Text('取消'),
            ),
            TextButton(
              onPressed: () => Get.back(result: true),
              child: const Text('确定申请'),
            ),
          ],
        ),
      );
      
      if (confirmed != true) return;
      
      // 提交申请
      await _submitJoinActivity(activity);
      
    } catch (e) {
      debugPrint('❌ 加入活动失败: $e');
      LoadingUtil.error('操作失败');
    }
  }
  
  /// 提交申请加入活动
  Future<void> _submitJoinActivity(ActivityEntity activity) async {
    try {
      debugPrint('📤 =============== 提交申请加入活动（使用BusinessOrchestrationService） ===============');
      debugPrint('🎯 活动ID: ${activity.activityId}');
      debugPrint('📝 活动标题: ${activity.activityTitle}');
      
      // 🔥 显示加载提示
      LoadingUtil.show('正在申请加入...');
      
      // 🔥 获取发布者信息
      final publisherId = activity.publisherId;
      final activityTitle = activity.activityTitle;
      
      if (publisherId == null) {
        LoadingUtil.dismiss();
        LoadingUtil.error('活动信息不完整');
        return;
      }
      
      // 🔥 使用BusinessOrchestrationService统一入口（API + IM通知）
      final result = await BusinessOrchestrationService.to.joinActivity(
        activityId: activity.activityId,
        publisherId: publisherId,
        activityTitle: activityTitle,
      );
      
      debugPrint('✅ 加入活动响应成功');
      
      // 🔥 关闭加载提示
      LoadingUtil.dismiss();
      
      if (result['status'] == 'success') {
        debugPrint('✅ 加入活动成功（已自动发送IM通知给发布者）');
        LoadingUtil.success(result['message'] ?? '申请成功');
      } else {
        final message = result['message'] ?? '';
        
        // 处理特殊情况（如重复参加）
        if (message.contains('重复') || message.contains('已参加')) {
          LoadingUtil.toast(message);
        } else {
          LoadingUtil.error(message.isNotEmpty ? message : '申请失败');
        }
      }
    } catch (e) {
      // 🔥 关闭加载提示
      LoadingUtil.dismiss();
      
      debugPrint('💥 加入活动异常: $e');
      
      final errorMsg = e.toString();
      
      if (errorMsg.contains('已参加') || errorMsg.contains('重复参加')) {
        await Get.dialog(
          AlertDialog(
            title: const Text('提示'),
            content: const Text('您已经申请加入过这个活动了，请耐心等待发布者审核'),
            actions: [
              TextButton(
                onPressed: () => Get.back(),
                child: const Text('知道了'),
              ),
            ],
          ),
        );
      } else {
        LoadingUtil.error('申请失败，请稍后重试');
      }
    }
  }
  
  // ==================== 页面跳转 ====================
  
  /// 跳转到历史记录页面
  void goToHistory() {
    debugPrint('📋 =============== 跳转历史记录页面 ===============');
    debugPrint('👤 目标用户ID: ${targetUserId.value}');
    debugPrint('👤 用户名: ${userInfo.value?.username}');
    
    if (targetUserId.value == 0) {
      LoadingUtil.info('用户信息不完整');
      return;
    }
    
    Get.toNamed(
      RouteNames.activityActiviteHistory,
      arguments: {
        'userId': targetUserId.value,
        'userName': userInfo.value?.username ?? '用户',
      },
    );
  }
  
  /// 开启聊天（仅好友可用）
  void onStartChat() {
    debugPrint('💬 =============== 开启聊天 ===============');
    debugPrint('👤 好友ID: ${targetUserId.value}');
    debugPrint('👤 好友昵称: ${userInfo.value?.username}');
    debugPrint('🤝 是否是好友: $isFriend');
    
    // 检查是否是好友
    if (!isFriend) {
      LoadingUtil.toast('只有好友才能聊天');
      return;
    }
    
    // 🔥 获取手机号
    final userPhone = userInfo.value?.userPhone;
    
    // 🔥 验证手机号
    if (userPhone == null || userPhone.isEmpty) {
      LoadingUtil.toast('无法获取用户手机号');
      debugPrint('⚠️ 用户手机号为空，userId=${targetUserId.value}');
      return;
    }
    
    debugPrint('👤 好友手机: $userPhone');  // 🔥 新增日志
    
    // 🔥 跳转到聊天页面（传递手机号）
    Get.toNamed(
      RouteNames.messageMessageChat,
      arguments: {
        'friendId': targetUserId.value,     // 数据库ID（用于UI）
        'friendPhone': userPhone,           // 🔥 手机号（用于融云）
        'friendName': userInfo.value?.username ?? '未知用户',
        'friendAvatar': userInfo.value?.userAvatarUrl ?? '',
      },
    );
  }
}
